A Select Dropdown is a common form control used on websites to allow users to choose one or more options from a predefined list. Examples include selecting a country, state, city, department, gender, category, month, year, payment method, or job role.
In Selenium WebDriver with Java, standard HTML dropdowns created using the <select> element can be handled conveniently using Selenium's Select class. The Select class provides methods such as selectByVisibleText(), selectByValue(), selectByIndex(), getOptions(), and methods for handling multiple selections.
Selenium Training: Selenium Training Course
Register for Course Demo: Register for Selenium Course Demo
A select dropdown is an HTML form element that presents a list of predefined options. The standard HTML structure uses the <select> element as the container and one or more <option> elements as its choices.
<select id="country">
<option value="india">India</option>
<option value="usa">United States</option>
<option value="uk">United Kingdom</option>
<option value="canada">Canada</option>
</select>
In this example, country is the select element and each country is an option.
Dropdowns are frequently used in real-world web applications. Automated tests often need to select a particular value and then verify that the correct value has been selected.
<label for="department">Department</label>
<select id="department" name="department">
<option value="it">IT</option>
<option value="hr">Human Resources</option>
<option value="finance">Finance</option>
<option value="sales">Sales</option>
</select>
The important elements are:
| Element/Attribute | Purpose |
|---|---|
| <select> | Creates the dropdown |
| <option> | Represents an option inside the dropdown |
| id | Provides a unique identifier |
| name | Identifies the form field |
| value | Provides the option's submitted value |
| multiple | Allows multiple options to be selected |
Selenium provides the org.openqa.selenium.support.ui.Select class for interacting with standard HTML <select> elements. The class wraps a WebElement representing a select element and provides specialized dropdown operations.
Import the Select class using:
import org.openqa.selenium.support.ui.Select;WebElement dropdown = driver.findElement(By.id("country"));
Select select = new Select(dropdown);
After creating the Select object, selection methods can be called on it.
WebElement countryDropdown =
driver.findElement(By.id("country"));
Select country =
new Select(countryDropdown);
country.selectByVisibleText("India");
selectByVisibleText() selects an option according to the text displayed to the user.
WebElement dropdown =
driver.findElement(By.id("country"));
Select select =
new Select(dropdown);
select.selectByVisibleText("India");
For example:
<select id="country">
<option value="in">India</option>
<option value="us">United States</option>
</select>
The following selects India:
select.selectByVisibleText("India");For most straightforward dropdown scenarios, visible text is often a clear way to express the intended selection.
selectByValue() selects an option by matching its HTML value attribute.
<select id="country">
<option value="in">India</option>
<option value="us">United States</option>
<option value="uk">United Kingdom</option>
</select>
Java Selenium:
Select select =
new Select(driver.findElement(By.id("country")));
select.selectByValue("in");
Use selectByValue() when the option's value attribute is stable and known.
select.selectByValue("india");This method is useful when visible text changes but the underlying value remains stable.
selectByIndex() selects an option using its index.
Select select =
new Select(driver.findElement(By.id("country")));
select.selectByIndex(2);
When using index-based selection, be careful if the application's option ordering can change.
<select id="city">
<option value="delhi">Delhi</option>
<option value="mumbai">Mumbai</option>
<option value="pune">Pune</option>
<option value="bangalore">Bangalore</option>
</select>
Select city =
new Select(driver.findElement(By.id("city")));
city.selectByIndex(2);
Index-based selection should be used carefully because changes to option ordering can make the test select a different option.
| Method | Selection Basis | Example |
|---|---|---|
| selectByVisibleText() | Displayed option text | India |
| selectByValue() | HTML value attribute | in |
| selectByIndex() | Option index | 2 |
| Feature | Visible Text | Value | Index |
|---|---|---|---|
| Uses displayed text | Yes | No | No |
| Uses value attribute | No | Yes | No |
| Uses index | No | No | Yes |
| Easy to read | Very easy | Easy | Moderate |
| Depends on option order | No | No | Yes |
| Useful for dynamic option text | Sometimes | Often | Sometimes |
Locate <select> element
|
v
Create Select object
|
v
Choose selection strategy
|
+----------------------+
| | |
v v v
Visible Text Value Index
| | |
+----------+-----------+
|
v
Option Selected
|
v
Verify Selection
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;
public class DropdownExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com");
WebElement countryDropdown =
driver.findElement(By.id("country"));
Select country =
new Select(countryDropdown);
country.selectByVisibleText("India");
} finally {
driver.quit();
}
}
}
The getOptions() method returns all options belonging to the select element.
Select select =
new Select(driver.findElement(By.id("country")));
List<WebElement> options =
select.getOptions();
Required import:
import java.util.List;List<WebElement> options = select.getOptions();
for (WebElement option : options) {
System.out.println(option.getText());
}
This is useful for debugging and validating that expected options are present.
WebElement dropdown =
driver.findElement(By.id("country"));
Select select =
new Select(dropdown);
List<WebElement> options =
select.getOptions();
for (WebElement option : options) {
System.out.println(
"Option: " + option.getText()
);
}
The getFirstSelectedOption() method returns the first selected option. For a normal single-select dropdown, this represents the currently selected option.
WebElement selected =
select.getFirstSelectedOption();
System.out.println(
selected.getText()
);
select.selectByVisibleText("India");
String selectedText =
select.getFirstSelectedOption().getText();
System.out.println(
"Selected: " + selectedText
);
TestNG assertion:
Assert.assertEquals(
selectedText,
"India"
);
The getAllSelectedOptions() method returns all currently selected options. For a normal single-select dropdown, this list generally contains one selected option; for a multiple-select dropdown, it can contain multiple options.
List<WebElement> selectedOptions =
select.getAllSelectedOptions();
for (WebElement option : selectedOptions) {
System.out.println(option.getText());
}
The isMultiple() method checks whether the select element supports selecting multiple options.
if (select.isMultiple()) {
System.out.println(
"Multiple selection is supported"
);
} else {
System.out.println(
"Single selection only"
);
}
A standard single-select dropdown allows one option to be selected at a time.
<select id="department">
<option value="it">IT</option>
<option value="hr">HR</option>
<option value="finance">Finance</option>
</select>
Example:
Select department =
new Select(
driver.findElement(
By.id("department")
)
);
department.selectByVisibleText("IT");
A multiple-select dropdown uses the multiple attribute and allows more than one option to be selected.
<select id="skills" multiple>
<option value="java">Java</option>
<option value="selenium">Selenium</option>
<option value="sql">SQL</option>
<option value="python">Python</option>
</select>
The Select methods can be called repeatedly for a multiple-select dropdown.
Select skills =
new Select(
driver.findElement(By.id("skills"))
);
skills.selectByVisibleText("Java");
skills.selectByVisibleText("Selenium");
skills.selectByVisibleText("SQL");
For multiple-select dropdowns, deselectByVisibleText() removes a selected option based on its displayed text.
skills.deselectByVisibleText("SQL");skills.deselectByValue("selenium");This removes the selected option whose value attribute matches the supplied value.
skills.deselectByIndex(2);This is applicable to multiple-select dropdowns.
The deselectAll() method clears all selected options. It is intended for multiple-select elements.
skills.deselectAll();Select skills =
new Select(
driver.findElement(By.id("skills"))
);
skills.selectByVisibleText("Java");
skills.selectByVisibleText("Selenium");
skills.selectByVisibleText("SQL");
skills.deselectByVisibleText("SQL");
WebElement skillsDropdown =
driver.findElement(By.id("skills"));
Select skills =
new Select(skillsDropdown);
skills.selectByVisibleText("Java");
skills.selectByVisibleText("Selenium");
skills.selectByVisibleText("SQL");
List<WebElement> selected =
skills.getAllSelectedOptions();
for (WebElement option : selected) {
System.out.println(
"Selected: " + option.getText()
);
}
An important point is that Selenium's Java Select class is designed for actual HTML <select> elements. It should not be used with custom dropdowns implemented using elements such as <div>, <li>, buttons, or other custom components.
| Standard Dropdown | Custom Dropdown |
|---|---|
| Uses <select> | Often uses <div>, <li>, buttons, etc. |
| Contains <option> | May contain custom elements |
| Can use Select class | Select class does not apply |
| selectByVisibleText() available | Must interact with elements directly |
| selectByValue() available | Usually handled with locators/clicks |
<div class="dropdown">
<button>Select Country</button>
<div class="options">
<div>India</div>
<div>United States</div>
<div>United Kingdom</div>
</div>
</div>
This is not a standard <select> element, so the Select class should not be used.
For a custom dropdown, interact with the actual elements displayed by the application.
driver.findElement(
By.cssSelector(".dropdown button")
).click();
driver.findElement(
By.xpath("//div[text()='India']")
).click();
The exact locator depends on the application's HTML structure.
The Select constructor expects the supplied WebElement to represent a SELECT element. If the element is not a select element, Selenium can throw an UnexpectedTagNameException.
WebElement element =
driver.findElement(By.id("country"));
Select select = new Select(element);
If the element is actually a div-based custom dropdown, the Select object should not be created for it.
Select country =
new Select(
driver.findElement(
By.id("country")
)
);
country.selectByVisibleText("India");
Select country =
new Select(
driver.findElement(
By.name("country")
)
);
country.selectByVisibleText("India");
Select country =
new Select(
driver.findElement(
By.cssSelector("#country")
)
);
country.selectByVisibleText("India");
Select country =
new Select(
driver.findElement(
By.xpath("//select[@id='country']")
)
);
country.selectByVisibleText("India");
WebElement countryElement =
driver.findElement(
By.id("country")
);
Select country =
new Select(countryElement);
country.selectByVisibleText("India");
This approach is often easier to debug because the WebElement and Select objects are clearly separated.
Test automation may need to verify that required options are available.
List<WebElement> options =
country.getOptions();
for (WebElement option : options) {
String text = option.getText();
System.out.println(text);
}
boolean optionFound = false;
for (WebElement option : country.getOptions()) {
if (option.getText().equals("India")) {
optionFound = true;
break;
}
}
System.out.println(
"India available: " + optionFound
);
Sometimes the option to select is stored in a variable.
String countryName = "India";
Select country =
new Select(
driver.findElement(
By.id("country")
)
);
country.selectByVisibleText(countryName);
This makes the same automation method reusable for different test data.
String[] countries = {
"India",
"United States",
"United Kingdom"
};
for (String countryName : countries) {
Select country =
new Select(
driver.findElement(
By.id("country")
)
);
country.selectByVisibleText(countryName);
System.out.println(
"Selected: " + countryName
);
}
WebElement countryElement =
driver.findElement(By.id("country"));
Select country =
new Select(countryElement);
country.selectByVisibleText("India");
String selected =
country.getFirstSelectedOption()
.getText();
Assert.assertEquals(
selected,
"India"
);
import java.util.List;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;
import org.testng.Assert;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.Select;
import org.testng.Assert;
import org.testng.annotations.Test;
public class DropdownTest {
@Test
public void selectCountry() {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com");
WebElement countryElement =
driver.findElement(
By.id("country")
);
Select country =
new Select(countryElement);
country.selectByVisibleText("India");
String selected =
country
.getFirstSelectedOption()
.getText();
Assert.assertEquals(
selected,
"India"
);
} finally {
driver.quit();
}
}
}
Launch Browser
|
v
Open Web Page
|
v
Locate <select> Element
|
v
Create Select Object
|
v
Choose Selection Method
|
+-------------------------+
| | |
v v v
Visible Text Value Index
| | |
+------------+------------+
|
v
Select Option
|
v
Verify Selection
|
v
Continue Test
Important test scenarios for dropdowns include:
A dropdown may have a default option selected when the page loads.
WebElement dropdown =
driver.findElement(By.id("country"));
Select select =
new Select(dropdown);
String defaultOption =
select.getFirstSelectedOption()
.getText();
System.out.println(
"Default: " + defaultOption
);
A dropdown can be disabled using the HTML disabled attribute.
<select id="country" disabled>
<option value="in">India</option>
<option value="us">United States</option>
</select>
Before interacting with a disabled dropdown, verify its state and ensure the test case reflects the expected application behavior.
An individual option can also be disabled.
<select id="country">
<option value="in">India</option>
<option value="us" disabled>United States</option>
</select>
A disabled option should not be treated as a valid selectable option in the test.
Many applications use dependent dropdowns. For example, selecting a country may dynamically populate a state dropdown.
Country
|
v
Select India
|
v
State Dropdown Updated
|
v
Select Maharashtra
|
v
City Dropdown Updated
|
v
Select Mumbai
In such cases, synchronization may be required between each selection and the appearance of the new options.
Select country =
new Select(
driver.findElement(
By.id("country")
)
);
country.selectByVisibleText("India");
// Wait for state options to become available
Select state =
new Select(
driver.findElement(
By.id("state")
)
);
state.selectByVisibleText("Maharashtra");
If a dropdown is populated asynchronously after another selection, use an appropriate explicit wait rather than assuming the options are immediately available.
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.findElements(
By.cssSelector("#state option")
).size() > 1
);
Required imports:
import java.time.Duration;
import org.openqa.selenium.support.ui.WebDriverWait;
country.selectByVisibleText("India");
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.findElements(
By.cssSelector("#state option")
).size() > 1
);
Select state =
new Select(
driver.findElement(
By.id("state")
)
);
state.selectByVisibleText("Maharashtra");
| Exception | Possible Cause |
|---|---|
| UnexpectedTagNameException | Element is not a <select> element |
| NoSuchElementException | Requested option does not exist |
| StaleElementReferenceException | Dropdown or option was refreshed/replaced |
| ElementNotInteractableException | Element cannot currently be interacted with |
| TimeoutException | Dynamic dropdown did not become ready within the wait period |
This exception commonly occurs when the Select class is used with a non-select element.
WebElement element =
driver.findElement(
By.id("customDropdown")
);
Select select =
new Select(element);
If customDropdown is a div, button, or another element instead of a select element, the Select class is inappropriate.
This can occur when the requested option cannot be found.
select.selectByVisibleText("Australia");If the dropdown does not contain an option matching the requested text, the operation fails.
Dropdown interactions can be encapsulated inside page classes.
public class RegistrationPage {
private WebDriver driver;
private By country =
By.id("country");
public RegistrationPage(
WebDriver driver) {
this.driver = driver;
}
public void selectCountry(
String countryName) {
Select select =
new Select(
driver.findElement(country)
);
select.selectByVisibleText(
countryName
);
}
public String getSelectedCountry() {
Select select =
new Select(
driver.findElement(country)
);
return select
.getFirstSelectedOption()
.getText();
}
}
RegistrationPage page =
new RegistrationPage(driver);
page.selectCountry("India");
Assert.assertEquals(
page.getSelectedCountry(),
"India"
);
A framework can provide a reusable utility method for selecting an option by visible text.
public static void selectByText(
WebDriver driver,
By locator,
String text) {
WebElement element =
driver.findElement(locator);
Select select =
new Select(element);
select.selectByVisibleText(text);
}
Usage:
DropdownUtils.selectByText(
driver,
By.id("country"),
"India"
);
public static void selectByValue(
WebDriver driver,
By locator,
String value) {
Select select =
new Select(
driver.findElement(locator)
);
select.selectByValue(value);
}
public static void selectByIndex(
WebDriver driver,
By locator,
int index) {
Select select =
new Select(
driver.findElement(locator)
);
select.selectByIndex(index);
}
Choose a selection strategy according to the application's HTML and test requirement.
Always inspect the HTML before using the Select class.
<select> --> Use Select class
<option> --> Option inside Select
<div> --> Handle directly
<button> --> Handle directly
<li> --> Handle directly
The Select class is intended for HTML select/option controls.
This code may become fragile if the order of options changes:
select.selectByIndex(3);If the test requirement is actually to select a named option, prefer:
select.selectByVisibleText("India");select.selectByVisibleText("India");
String selected =
select.getFirstSelectedOption()
.getText();
Assert.assertEquals(
selected,
"India"
);
Verification ensures that the intended selection was actually applied.
For dropdowns whose options are populated after an AJAX or JavaScript operation, wait for the expected condition before selecting.
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.findElements(
By.cssSelector(
"#state option"
)
).size() > 1
);
In a larger Selenium framework, repeated dropdown operations should be placed into reusable utilities or Page Object methods.
selectByText(driver, By.id("country"), "India");
selectByText(driver, By.id("state"), "Maharashtra");
selectByText(driver, By.id("city"), "Mumbai");
This reduces duplicate code and makes test cases easier to maintain.
| Incorrect/Fragile | Better Approach |
|---|---|
| Use Select on a div dropdown | Interact with the custom dropdown elements |
| Always use index | Use visible text or value when appropriate |
| Select immediately after AJAX update | Wait for expected options |
| Do not verify selection | Use getFirstSelectedOption() |
| Use random locator | Use stable ID/name/CSS/XPath |
| Ignore disabled options | Verify enabled/disabled state when required |
Scenario: Automate a registration form containing country, state, city, department, and skills dropdowns.
Open Registration Page
|
v
Select Country
|
v
Wait for States
|
v
Select State
|
v
Wait for Cities
|
v
Select City
|
v
Select Department
|
v
Select Skills
|
v
Verify Selections
|
v
Submit Form
|
v
Verify Success
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com/registration");
Select country =
new Select(
driver.findElement(
By.id("country")
)
);
country.selectByVisibleText("India");
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
d -> d.findElements(
By.cssSelector(
"#state option"
)
).size() > 1
);
Select state =
new Select(
driver.findElement(
By.id("state")
)
);
state.selectByVisibleText("Maharashtra");
wait.until(
d -> d.findElements(
By.cssSelector(
"#city option"
)
).size() > 1
);
Select city =
new Select(
driver.findElement(
By.id("city")
)
);
city.selectByVisibleText("Mumbai");
Select department =
new Select(
driver.findElement(
By.id("department")
)
);
department.selectByVisibleText("IT");
} finally {
driver.quit();
}
// Locate dropdown
WebElement element =
driver.findElement(By.id("country"));
// Create Select object
Select select =
new Select(element);
// Select by text
select.selectByVisibleText("India");
// Select by value
select.selectByValue("in");
// Select by index
select.selectByIndex(1);
// Get all options
List<WebElement> options =
select.getOptions();
// Get selected option
WebElement selected =
select.getFirstSelectedOption();
// Get all selected options
List<WebElement> selectedOptions =
select.getAllSelectedOptions();
// Check multiple selection
boolean multiple =
select.isMultiple();
// Deselect by text
select.deselectByVisibleText("India");
// Deselect by value
select.deselectByValue("in");
// Deselect by index
select.deselectByIndex(1);
// Deselect all
select.deselectAll();
Answer: The Select class is a Selenium support class used to interact with standard HTML <select> dropdown elements. It provides methods for selecting, deselecting, retrieving options, and checking multiple-selection support.
Answer:
Select select =
new Select(
driver.findElement(
By.id("country")
)
);
select.selectByVisibleText("India");
Answer:
select.selectByValue("in");Answer:
select.selectByIndex(2);Answer: No. Selenium's Select class is designed for HTML <select> elements. A custom dropdown implemented using elements such as div, li, or buttons must be handled by interacting with those elements directly.
Answer: Use getOptions().
List<WebElement> options =
select.getOptions();
Answer: Use getFirstSelectedOption().
WebElement selected =
select.getFirstSelectedOption();
Answer: Use isMultiple().
boolean multiple =
select.isMultiple();
Answer: Deselect operations are intended for multiple-select dropdowns. A normal single-select dropdown does not support clearing an individual selection through the multiple-select deselection API.
Answer: selectByVisibleText() selects an option according to the text displayed to the user, whereas selectByValue() selects an option according to its HTML value attribute.
Answer: The appropriate method depends on the application. Use visible text when the displayed label is the stable identifier, value when the HTML value is stable and suitable, and index only when index-based selection is intentional and reliable.
Answer: Selenium's Select constructor checks the element's tag name. If it is not a SELECT element, an UnexpectedTagNameException can be thrown.
| Method | Purpose |
|---|---|
| selectByVisibleText() | Select option by displayed text |
| selectByValue() | Select option by value attribute |
| selectByIndex() | Select option by index |
| getOptions() | Get all options |
| getFirstSelectedOption() | Get first/current selected option |
| getAllSelectedOptions() | Get all selected options |
| isMultiple() | Check multiple-selection support |
| deselectByVisibleText() | Deselect by visible text |
| deselectByValue() | Deselect by value |
| deselectByIndex() | Deselect by index |
| deselectAll() | Deselect all options in a multi-select |
1. Inspect the dropdown.
2. Check whether it is a <select> element.
3. Locate the dropdown.
4. Create a Select object.
5. Select using:
- selectByVisibleText()
- selectByValue()
- selectByIndex()
6. Verify the selected option.
7. For multiple select:
- select multiple options
- use deselect methods
8. For dynamic dropdowns:
- use explicit waits
9. For custom dropdowns:
- do not use Select class
10. Keep dropdown logic reusable.
Select Dropdown handling is an essential Selenium WebDriver skill because dropdown controls appear in registration forms, search forms, checkout pages, profile pages, administration panels, filters, and many other web applications.
For a standard HTML <select> element, Selenium's Select class provides a convenient API for selecting options by visible text, value, or index, retrieving available and selected options, and working with multiple-select controls.
The most important concept is to first inspect the HTML. If the control is a genuine <select> element, use the Select class. If the application uses a custom dropdown built with divs, buttons, list items, or JavaScript overlays, interact with the actual elements instead.
For reliable automation, use stable locators, select options using meaningful identifiers, wait for dynamically populated options, verify the selected value, and keep reusable dropdown logic inside utility or Page Object classes.
To learn Selenium WebDriver, dropdown handling, locators, waits, browser automation, Page Object Model, TestNG, framework development, and practical automation testing, explore the following resources:
